home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / GramMod.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  37KB  |  1,445 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_IO
  16. #include "IO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Strings
  20. #include "Strings.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_StringMem
  24. #include "StringMem.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Idents
  28. #include "Idents.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Texts
  32. #include "Texts.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Sets
  36. #include "Sets.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_TreeMod2
  40. #include "TreeMod2.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Tree
  44. #include "Tree.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Strings
  48. #include "Strings.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_GramMod
  52. #include "GramMod.h"
  53. #endif
  54.  
  55. IO_tFile GramMod_yyf;
  56. PROC GramMod_Exit;
  57.  
  58. static Tree_tTree Node, ActClass, TheClass, TheAttr;
  59. static Idents_tIdent iOper, iLeft, iRight, iNone, iPrec, iRule;
  60. static SHORTCARD ActActionIndex, PrevActionIndex, i;
  61. static BOOLEAN IsImplicit;
  62. static Strings_tString s;
  63. static Tree_tTree GetBaseClass ARGS((Tree_tTree Class));
  64. static BOOLEAN IsLast ARGS((Tree_tTree Class, Tree_tTree Action));
  65. static void IsLast2 ARGS((Tree_tTree t, Tree_tTree Action, BOOLEAN *pFound, BOOLEAN *pLast));
  66. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  67. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  68. struct S_3 {
  69.     union {
  70.         char dummy;
  71.     } U_1;
  72. };
  73. struct S_4 {
  74.     union {
  75.         char dummy;
  76.     } U_1;
  77. };
  78. static void ErrorActions ARGS((Tree_tTree t));
  79. struct S_5 {
  80.     union {
  81.         char dummy;
  82.     } U_1;
  83. };
  84. static void ScanVariant ARGS((Tree_tTree t));
  85. struct S_6 {
  86.     union {
  87.         char dummy;
  88.     } U_1;
  89. };
  90. static void ScanAttr ARGS((Tree_tTree t));
  91. struct S_7 {
  92.     union {
  93.         char dummy;
  94.     } U_1;
  95. };
  96. static void ParsVariant ARGS((Tree_tTree t));
  97. struct S_8 {
  98.     union {
  99.         char dummy;
  100.     } U_1;
  101. };
  102. static void GenExt ARGS((Tree_tTree t));
  103. struct S_9 {
  104.     union {
  105.         char dummy;
  106.     } U_1;
  107. };
  108. static void Token ARGS((Tree_tTree t));
  109. struct S_10 {
  110.     union {
  111.         char dummy;
  112.     } U_1;
  113. };
  114. static void RecordField ARGS((Tree_tTree t));
  115. struct S_11 {
  116.     union {
  117.         char dummy;
  118.     } U_1;
  119. };
  120. static void PrecDefs ARGS((Tree_tTree t));
  121. struct S_12 {
  122.     union {
  123.         char dummy;
  124.     } U_1;
  125. };
  126. static void Grammar ARGS((Tree_tTree t));
  127. struct S_13 {
  128.     union {
  129.         char dummy;
  130.     } U_1;
  131. };
  132. static void Rule ARGS((Tree_tTree t));
  133. struct S_14 {
  134.     union {
  135.         char dummy;
  136.     } U_1;
  137. };
  138. static void Implicit ARGS((Tree_tTree t));
  139. struct S_15 {
  140.     union {
  141.         char dummy;
  142.     } U_1;
  143. };
  144. static void WriteName ARGS((Idents_tIdent Name));
  145. struct S_16 {
  146.     union {
  147.         char dummy;
  148.     } U_1;
  149. };
  150. static void yyExit ARGS(());
  151.  
  152.  
  153. static Tree_tTree GetBaseClass
  154. # ifdef __STDC__
  155. (Tree_tTree Class)
  156. # else
  157. (Class)
  158. Tree_tTree Class;
  159. # endif
  160. {
  161.   while (Class->U_1.V_5.Class.BaseClass->U_1.V_1.Kind != Tree_NoClass) {
  162.     Class = Class->U_1.V_5.Class.BaseClass;
  163.   }
  164.   return Class;
  165. }
  166.  
  167. static BOOLEAN IsLast
  168. # ifdef __STDC__
  169. (Tree_tTree Class, Tree_tTree Action)
  170. # else
  171. (Class, Action)
  172. Tree_tTree Class, Action;
  173. # endif
  174. {
  175.   BOOLEAN Found, Last;
  176.  
  177.   IsLast2(Class, Action, &Found, &Last);
  178.   return Last;
  179. }
  180.  
  181. static void IsLast2
  182. # ifdef __STDC__
  183. (Tree_tTree t, Tree_tTree Action, BOOLEAN *pFound, BOOLEAN *pLast)
  184. # else
  185. (t, Action, pFound, pLast)
  186. Tree_tTree t, Action;
  187. BOOLEAN *pFound, *pLast;
  188. # endif
  189. {
  190.   BOOLEAN Found, Last;
  191.  
  192.   switch (t->U_1.V_1.Kind) {
  193.   case Tree_Class:;
  194.     IsLast2(t->U_1.V_5.Class.Attributes, Action, pFound, pLast);
  195.     if (*pFound || !*pLast) {
  196.       return;
  197.     }
  198.     IsLast2(t->U_1.V_5.Class.BaseClass, Action, pFound, pLast);
  199.     break;
  200.   case Tree_Child:;
  201.     IsLast2(t->U_1.V_9.Child.Next, Action, &Found, &Last);
  202.     *pFound = Found;
  203.     if (Found) {
  204.       *pLast = Last;
  205.     } else {
  206.       *pLast = FALSE;
  207.     }
  208.     break;
  209.   case Tree_Attribute:;
  210.     IsLast2(t->U_1.V_10.Attribute.Next, Action, pFound, pLast);
  211.     break;
  212.   case Tree_ActionPart:;
  213.     IsLast2(t->U_1.V_11.ActionPart.Next, Action, &Found, &Last);
  214.     *pFound = Found || Action == t;
  215.     if (Found) {
  216.       *pLast = Last;
  217.     } else {
  218.       *pLast = Last && Action == t;
  219.     }
  220.     break;
  221.   default :
  222.     *pFound = FALSE;
  223.     *pLast = TRUE;
  224.     break;
  225.   }
  226. }
  227.  
  228. static void yyAbort
  229. # ifdef __STDC__
  230. (CHAR yyFunction[], LONGCARD O_1)
  231. # else
  232. (yyFunction, O_1)
  233. CHAR yyFunction[];
  234. LONGCARD O_1;
  235. # endif
  236. {
  237.   OPEN_ARRAY_LOCALS
  238.  
  239.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  240.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  241.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module GramMod, routine ", 31L);
  242.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  243.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  244.   IO_WriteNl((System_tFile)IO_StdError);
  245.   (*GramMod_Exit)();
  246.   FREE_OPEN_ARRAYS
  247. }
  248.  
  249. static BOOLEAN yyIsEqual
  250. # ifdef __STDC__
  251. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  252. # else
  253. (yya, O_3, yyb, O_2)
  254. BYTE yya[];
  255. LONGCARD O_3;
  256. BYTE yyb[];
  257. LONGCARD O_2;
  258. # endif
  259. {
  260.   INTEGER yyi;
  261.   OPEN_ARRAY_LOCALS
  262.  
  263.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  264.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  265.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  266.   {
  267.     LONGINT B_1 = 0, B_2 = (INTEGER)(O_3 - 1);
  268.  
  269.     if (B_1 <= B_2)
  270.       for (yyi = B_1;; yyi += 1) {
  271.         if (yya[yyi] != yyb[yyi]) {
  272.           FREE_OPEN_ARRAYS
  273.           return FALSE;
  274.         }
  275.         if (yyi >= B_2) break;
  276.       }
  277.   }
  278.   FREE_OPEN_ARRAYS
  279.   return TRUE;
  280. }
  281.  
  282. void GramMod_ParsSpec
  283. # ifdef __STDC__
  284. (Tree_tTree t)
  285. # else
  286. (t)
  287. Tree_tTree t;
  288. # endif
  289. {
  290.   struct S_3 yyTempo;
  291.  
  292.   if (t == Tree_NoTree) {
  293.     return;
  294.   }
  295.   if (t->U_1.V_1.Kind == Tree_Ag) {
  296.     {
  297.       register Tree_yAg *W_1 = &t->U_1.V_26.Ag;
  298.  
  299.       if (W_1->ScannerName != Idents_NoIdent) {
  300.         IO_WriteS(Tree_f, (STRING)"SCANNER ", 8L);
  301.         Tree_WI(W_1->ScannerName);
  302.       }
  303.       IO_WriteS(Tree_f, (STRING)" PARSER ", 8L);
  304.       Tree_WI(W_1->ParserName);
  305.       IO_WriteNl(Tree_f);
  306.       IO_WriteS(Tree_f, (STRING)"GLOBAL {", 8L);
  307.       IO_WriteNl(Tree_f);
  308.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Global);
  309.       Node = W_1->Modules;
  310.       while (Node->U_1.V_1.Kind == Tree_Module) {
  311.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Global);
  312.         Node = Node->U_1.V_43.Module.Next;
  313.       }
  314.       IO_WriteS(Tree_f, (STRING)"TYPE", 4L);
  315.       IO_WriteNl(Tree_f);
  316.       ParsVariant(W_1->Classes);
  317.       IO_WriteNl(Tree_f);
  318.       IO_WriteS(Tree_f, (STRING)"tParsAttribute = RECORD CASE : SHORTCARD OF", 43L);
  319.       IO_WriteNl(Tree_f);
  320.       IO_WriteS(Tree_f, (STRING)"  0: Scan: ", 11L);
  321.       if (W_1->ScannerName != Idents_NoIdent) {
  322.         Tree_WI(W_1->ScannerName);
  323.       } else {
  324.         IO_WriteS(Tree_f, (STRING)"Scanner", 7L);
  325.       }
  326.       IO_WriteS(Tree_f, (STRING)".tScanAttribute;", 16L);
  327.       IO_WriteNl(Tree_f);
  328.       i = 0;
  329.       Node = W_1->Classes;
  330.       while (Node->U_1.V_1.Kind == Tree_Class) {
  331.         {
  332.           register Tree_yClass *W_2 = &Node->U_1.V_5.Class;
  333.  
  334.           if (SET_IS_SUBSET1(SET_ELEM(Tree_Nonterminal) | SET_ELEM(Tree_Referenced) | SET_ELEM(Tree_HasAttributes), W_2->Properties)) {
  335.             INC(i);
  336.             IO_WriteS(Tree_f, (STRING)"| ", 2L);
  337.             Tree_WN((LONGINT)i);
  338.             IO_WriteS(Tree_f, (STRING)": ", 2L);
  339.             if (IN(Tree_String, W_2->Properties) && !IN(Tree_HasSelector, W_2->Properties)) {
  340.               IO_WriteS(Tree_f, (STRING)"(* ", 3L);
  341.               Tree_WE(W_2->Name);
  342.               IO_WriteS(Tree_f, (STRING)" *) yy", 6L);
  343.               Tree_WN((LONGINT)W_2->Name);
  344.               IO_WriteS(Tree_f, (STRING)": yy", 4L);
  345.               Tree_WN((LONGINT)W_2->Name);
  346.               IO_WriteS(Tree_f, (STRING)";", 1L);
  347.               IO_WriteNl(Tree_f);
  348.             } else {
  349.               Tree_WI(W_2->Selector);
  350.               IO_WriteS(Tree_f, (STRING)": yy", 4L);
  351.               Tree_WI(W_2->Selector);
  352.               IO_WriteS(Tree_f, (STRING)";", 1L);
  353.               IO_WriteNl(Tree_f);
  354.             }
  355.           }
  356.           Node = W_2->Next;
  357.         }
  358.       }
  359.       IO_WriteS(Tree_f, (STRING)"END; END;", 9L);
  360.       IO_WriteNl(Tree_f);
  361.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  362.       IO_WriteNl(Tree_f);
  363.       IO_WriteNl(Tree_f);
  364.       IO_WriteS(Tree_f, (STRING)"EXPORT {", 8L);
  365.       IO_WriteNl(Tree_f);
  366.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Export);
  367.       Node = W_1->Modules;
  368.       while (Node->U_1.V_1.Kind == Tree_Module) {
  369.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Export);
  370.         Node = Node->U_1.V_43.Module.Next;
  371.       }
  372.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  373.       IO_WriteNl(Tree_f);
  374.       IO_WriteNl(Tree_f);
  375.       IO_WriteS(Tree_f, (STRING)"LOCAL {", 7L);
  376.       IO_WriteNl(Tree_f);
  377.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Local);
  378.       Node = W_1->Modules;
  379.       while (Node->U_1.V_1.Kind == Tree_Module) {
  380.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Local);
  381.         Node = Node->U_1.V_43.Module.Next;
  382.       }
  383.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  384.       IO_WriteNl(Tree_f);
  385.       IO_WriteNl(Tree_f);
  386.       IO_WriteS(Tree_f, (STRING)"BEGIN {", 7L);
  387.       IO_WriteNl(Tree_f);
  388.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Begin);
  389.       Node = W_1->Modules;
  390.       while (Node->U_1.V_1.Kind == Tree_Module) {
  391.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Begin);
  392.         Node = Node->U_1.V_43.Module.Next;
  393.       }
  394.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  395.       IO_WriteNl(Tree_f);
  396.       IO_WriteNl(Tree_f);
  397.       IO_WriteS(Tree_f, (STRING)"CLOSE {", 7L);
  398.       IO_WriteNl(Tree_f);
  399.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Close);
  400.       Node = W_1->Modules;
  401.       while (Node->U_1.V_1.Kind == Tree_Module) {
  402.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Close);
  403.         Node = Node->U_1.V_43.Module.Next;
  404.       }
  405.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  406.       IO_WriteNl(Tree_f);
  407.       IO_WriteNl(Tree_f);
  408.       IO_WriteS(Tree_f, (STRING)"TOKEN", 5L);
  409.       IO_WriteNl(Tree_f);
  410.       IO_WriteNl(Tree_f);
  411.       Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)Token);
  412.       IO_WriteNl(Tree_f);
  413.       IO_WriteS(Tree_f, (STRING)"OPER", 4L);
  414.       IO_WriteNl(Tree_f);
  415.       IO_WriteNl(Tree_f);
  416.       PrecDefs(W_1->Precs);
  417.       IO_WriteNl(Tree_f);
  418.       IO_WriteS(Tree_f, (STRING)"RULE", 4L);
  419.       IO_WriteNl(Tree_f);
  420.       IO_WriteNl(Tree_f);
  421.       Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)GramMod_ParsSpec);
  422.       return;
  423.     }
  424.   }
  425.   if (t->U_1.V_1.Kind == Tree_Class) {
  426.     {
  427.       register Tree_yClass *W_3 = &t->U_1.V_5.Class;
  428.  
  429.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Nonterminal) | SET_ELEM(Tree_Referenced), W_3->Properties)) {
  430.         TheClass = t;
  431.         Grammar(t);
  432.       }
  433.       return;
  434.     }
  435.   }
  436. }
  437.  
  438. void GramMod_ScanSpec
  439. # ifdef __STDC__
  440. (Tree_tTree t)
  441. # else
  442. (t)
  443. Tree_tTree t;
  444. # endif
  445. {
  446.   struct S_4 yyTempo;
  447.  
  448.   if (t == Tree_NoTree) {
  449.     return;
  450.   }
  451.   if (t->U_1.V_1.Kind == Tree_Ag) {
  452.     {
  453.       register Tree_yAg *W_4 = &t->U_1.V_26.Ag;
  454.  
  455.       IO_WriteS(Tree_f, (STRING)"m", 1L);
  456.       IO_WriteNl(Tree_f);
  457.       IO_WriteS(Tree_f, (STRING)"TYPE", 4L);
  458.       IO_WriteNl(Tree_f);
  459.       Tree_ForallClasses(W_4->Classes, (Tree_ProcOfT)ScanVariant);
  460.       IO_WriteNl(Tree_f);
  461.       IO_WriteS(Tree_f, (STRING)"tScanAttribute = RECORD", 23L);
  462.       IO_WriteNl(Tree_f);
  463.       IO_WriteS(Tree_f, (STRING)"Position: tPosition;", 20L);
  464.       IO_WriteNl(Tree_f);
  465.       IO_WriteS(Tree_f, (STRING)"CASE : SHORTCARD OF", 19L);
  466.       IO_WriteNl(Tree_f);
  467.       Tree_ForallClasses(W_4->Classes, (Tree_ProcOfT)ScanAttr);
  468.       IO_WriteS(Tree_f, (STRING)"END; END;", 9L);
  469.       IO_WriteNl(Tree_f);
  470.       IO_WriteNl(Tree_f);
  471.       IO_WriteS(Tree_f, (STRING)"PROCEDURE ErrorAttribute (Token: INTEGER; VAR pAttribute: tScanAttribute);", 74L);
  472.       IO_WriteNl(Tree_f);
  473.       IO_WriteS(Tree_f, (STRING)"%%", 2L);
  474.       IO_WriteNl(Tree_f);
  475.       IO_WriteS(Tree_f, (STRING)"PROCEDURE ErrorAttribute (Token: INTEGER; VAR pAttribute: tScanAttribute);", 74L);
  476.       IO_WriteNl(Tree_f);
  477.       IO_WriteS(Tree_f, (STRING)"BEGIN", 5L);
  478.       IO_WriteNl(Tree_f);
  479.       IO_WriteS(Tree_f, (STRING)" pAttribute.Position := Attribute.Position;", 43L);
  480.       IO_WriteNl(Tree_f);
  481.       IO_WriteS(Tree_f, (STRING)" CASE Token OF", 14L);
  482.       IO_WriteNl(Tree_f);
  483.       Tree_ForallClasses(W_4->Classes, (Tree_ProcOfT)ErrorActions);
  484.       IO_WriteS(Tree_f, (STRING)" ELSE", 5L);
  485.       IO_WriteNl(Tree_f);
  486.       IO_WriteS(Tree_f, (STRING)" END;", 5L);
  487.       IO_WriteNl(Tree_f);
  488.       IO_WriteS(Tree_f, (STRING)"END ErrorAttribute;", 19L);
  489.       IO_WriteNl(Tree_f);
  490.       IO_WriteS(Tree_f, (STRING)"%%", 2L);
  491.       IO_WriteNl(Tree_f);
  492.       Tree_ForallClasses(W_4->Classes, (Tree_ProcOfT)GramMod_ScanSpec);
  493.       return;
  494.     }
  495.   }
  496.   if (t->U_1.V_1.Kind == Tree_Class) {
  497.     {
  498.       register Tree_yClass *W_5 = &t->U_1.V_5.Class;
  499.  
  500.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Terminal) | SET_ELEM(Tree_Referenced), W_5->Properties)) {
  501.         Tree_WN((LONGINT)W_5->Code);
  502.         if (IN(Tree_HasAttributes, W_5->Properties)) {
  503.           IO_WriteS(Tree_f, (STRING)" S ", 3L);
  504.         } else {
  505.           IO_WriteS(Tree_f, (STRING)" N ", 3L);
  506.         }
  507.         if (IN(Tree_String, W_5->Properties) && !IN(Tree_HasSelector, W_5->Properties)) {
  508.           IO_WriteS(Tree_f, (STRING)"yy", 2L);
  509.           Tree_WN((LONGINT)W_5->Code);
  510.         } else {
  511.           Tree_WI(W_5->Selector);
  512.         }
  513.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  514.         Tree_WI(W_5->Name);
  515.         IO_WriteNl(Tree_f);
  516.       }
  517.       return;
  518.     }
  519.   }
  520. }
  521.  
  522. static void ErrorActions
  523. # ifdef __STDC__
  524. (Tree_tTree t)
  525. # else
  526. (t)
  527. Tree_tTree t;
  528. # endif
  529. {
  530.   struct S_5 yyTempo;
  531.  
  532.   if (t == Tree_NoTree) {
  533.     return;
  534.   }
  535.   switch (t->U_1.V_1.Kind) {
  536.   case Tree_Class:;
  537.     {
  538.       register Tree_yClass *W_6 = &t->U_1.V_5.Class;
  539.  
  540.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Terminal) | SET_ELEM(Tree_Referenced) | SET_ELEM(Tree_HasAttributes), W_6->Properties)) {
  541.         IO_WriteS(Tree_f, (STRING)" | (* ", 6L);
  542.         Tree_WE(W_6->Name);
  543.         IO_WriteS(Tree_f, (STRING)" *) ", 4L);
  544.         Tree_WN((LONGINT)W_6->Code);
  545.         IO_WriteS(Tree_f, (STRING)": ", 2L);
  546.         IO_WriteNl(Tree_f);
  547.         TheClass = t;
  548.         Tree_ForallAttributes(t, (Tree_ProcOfT)ErrorActions);
  549.       }
  550.       return;
  551.     }
  552.     break;
  553.   case Tree_ActionPart:;
  554.     {
  555.       register Tree_yActionPart *W_7 = &t->U_1.V_11.ActionPart;
  556.  
  557.       ErrorActions(W_7->Actions);
  558.       return;
  559.     }
  560.     break;
  561.   case Tree_Assign:;
  562.     {
  563.       register Tree_yAssign *W_8 = &t->U_1.V_36.Assign;
  564.  
  565.       ErrorActions(W_8->Results);
  566.       IO_WriteS(Tree_f, (STRING)":=", 2L);
  567.       ErrorActions(W_8->Arguments);
  568.       IO_WriteS(Tree_f, (STRING)";", 1L);
  569.       IO_WriteNl(Tree_f);
  570.       ErrorActions(W_8->Next);
  571.       return;
  572.     }
  573.     break;
  574.   case Tree_Copy:;
  575.     {
  576.       register Tree_yCopy *W_9 = &t->U_1.V_37.Copy;
  577.  
  578.       ErrorActions(W_9->Results);
  579.       IO_WriteS(Tree_f, (STRING)" := ", 4L);
  580.       ErrorActions(W_9->Arguments);
  581.       IO_WriteS(Tree_f, (STRING)";", 1L);
  582.       IO_WriteNl(Tree_f);
  583.       ErrorActions(W_9->Next);
  584.       return;
  585.     }
  586.     break;
  587.   case Tree_TargetCode:;
  588.     {
  589.       register Tree_yTargetCode *W_10 = &t->U_1.V_38.TargetCode;
  590.  
  591.       ErrorActions(W_10->Code);
  592.       IO_WriteS(Tree_f, (STRING)";", 1L);
  593.       IO_WriteNl(Tree_f);
  594.       ErrorActions(W_10->Next);
  595.       return;
  596.     }
  597.     break;
  598.   case Tree_Order:;
  599.     {
  600.       register Tree_yOrder *W_11 = &t->U_1.V_39.Order;
  601.  
  602.       ErrorActions(W_11->Next);
  603.       return;
  604.     }
  605.     break;
  606.   case Tree_Check:;
  607.     {
  608.       register Tree_yCheck *W_12 = &t->U_1.V_40.Check;
  609.  
  610.       if (W_12->Statement != Tree_NoTree) {
  611.         if (W_12->Condition != Tree_NoTree) {
  612.           IO_WriteS(Tree_f, (STRING)"IF NOT (", 8L);
  613.           ErrorActions(W_12->Condition);
  614.           IO_WriteS(Tree_f, (STRING)") THEN ", 7L);
  615.           ErrorActions(W_12->Statement);
  616.           IO_WriteS(Tree_f, (STRING)"; END;", 6L);
  617.           IO_WriteNl(Tree_f);
  618.         } else {
  619.           ErrorActions(W_12->Statement);
  620.           IO_WriteS(Tree_f, (STRING)";", 1L);
  621.           IO_WriteNl(Tree_f);
  622.         }
  623.       } else {
  624.         IO_WriteS(Tree_f, (STRING)"IF ", 3L);
  625.         ErrorActions(W_12->Condition);
  626.         IO_WriteS(Tree_f, (STRING)" THEN END;", 10L);
  627.         IO_WriteNl(Tree_f);
  628.       }
  629.       ErrorActions(W_12->Next);
  630.       return;
  631.     }
  632.     break;
  633.   case Tree_Designator:;
  634.     {
  635.       register Tree_yDesignator *W_13 = &t->U_1.V_15.Designator;
  636.  
  637.       Tree_WI(W_13->Selector);
  638.       IO_WriteS(Tree_f, (STRING)":", 1L);
  639.       Tree_WI(W_13->Attribute);
  640.       ErrorActions(W_13->Next);
  641.       return;
  642.     }
  643.     break;
  644.   case Tree_Ident:;
  645.     {
  646.       register Tree_yIdent *W_14 = &t->U_1.V_16.Ident;
  647.  
  648.       TheAttr = Tree_IdentifyAttribute(TheClass, W_14->Attribute);
  649.       if (TheAttr != Tree_NoTree) {
  650.         IO_WriteS(Tree_f, (STRING)"pAttribute", 10L);
  651.         if (W_14->Attribute == Tree_iPosition) {
  652.         } else if (IN(Tree_String, TheClass->U_1.V_5.Class.Properties) && !IN(Tree_HasSelector, TheClass->U_1.V_5.Class.Properties)) {
  653.           IO_WriteS(Tree_f, (STRING)".yy", 3L);
  654.           Tree_WN((LONGINT)TheClass->U_1.V_5.Class.Code);
  655.         } else {
  656.           IO_WriteS(Tree_f, (STRING)".", 1L);
  657.           Tree_WI(TheClass->U_1.V_5.Class.Selector);
  658.         }
  659.         IO_WriteS(Tree_f, (STRING)".", 1L);
  660.       }
  661.       Tree_WI(W_14->Attribute);
  662.       ErrorActions(W_14->Next);
  663.       return;
  664.     }
  665.     break;
  666.   case Tree_Any:;
  667.     {
  668.       register Tree_yAny *W_15 = &t->U_1.V_18.Any;
  669.  
  670.       StringMem_WriteString(Tree_f, W_15->Code);
  671.       ErrorActions(W_15->Next);
  672.       return;
  673.     }
  674.     break;
  675.   case Tree_Anys:;
  676.     {
  677.       register Tree_yAnys *W_16 = &t->U_1.V_19.Anys;
  678.  
  679.       ErrorActions(W_16->Layouts);
  680.       ErrorActions(W_16->Next);
  681.       return;
  682.     }
  683.     break;
  684.   case Tree_LayoutAny:;
  685.     {
  686.       register Tree_yLayoutAny *W_17 = &t->U_1.V_22.LayoutAny;
  687.  
  688.       StringMem_WriteString(Tree_f, W_17->Code);
  689.       ErrorActions(W_17->Next);
  690.       return;
  691.     }
  692.     break;
  693.   default :
  694.     break;
  695.   }
  696. }
  697.  
  698. static void ScanVariant
  699. # ifdef __STDC__
  700. (Tree_tTree t)
  701. # else
  702. (t)
  703. Tree_tTree t;
  704. # endif
  705. {
  706.   struct S_6 yyTempo;
  707.  
  708.   if (t == Tree_NoTree) {
  709.     return;
  710.   }
  711.   if (t->U_1.V_1.Kind == Tree_Class) {
  712.     {
  713.       register Tree_yClass *W_18 = &t->U_1.V_5.Class;
  714.  
  715.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Terminal) | SET_ELEM(Tree_Referenced) | SET_ELEM(Tree_HasAttributes), W_18->Properties)) {
  716.         if (IN(Tree_String, W_18->Properties) && !IN(Tree_HasSelector, W_18->Properties)) {
  717.           IO_WriteS(Tree_f, (STRING)"(* ", 3L);
  718.           Tree_WE(W_18->Name);
  719.           IO_WriteS(Tree_f, (STRING)" *) yy", 6L);
  720.           Tree_WN((LONGINT)W_18->Code);
  721.           IO_WriteS(Tree_f, (STRING)" = RECORD ", 10L);
  722.         } else {
  723.           IO_WriteS(Tree_f, (STRING)"yy", 2L);
  724.           Tree_WI(W_18->Selector);
  725.           IO_WriteS(Tree_f, (STRING)" = RECORD ", 10L);
  726.         }
  727.         TheClass = t;
  728.         Tree_ForallAttributes(t, (Tree_ProcOfT)RecordField);
  729.         IO_WriteS(Tree_f, (STRING)"END;", 4L);
  730.         IO_WriteNl(Tree_f);
  731.       }
  732.       return;
  733.     }
  734.   }
  735. }
  736.  
  737. static void ScanAttr
  738. # ifdef __STDC__
  739. (Tree_tTree t)
  740. # else
  741. (t)
  742. Tree_tTree t;
  743. # endif
  744. {
  745.   struct S_7 yyTempo;
  746.  
  747.   if (t == Tree_NoTree) {
  748.     return;
  749.   }
  750.   if (t->U_1.V_1.Kind == Tree_Class) {
  751.     {
  752.       register Tree_yClass *W_19 = &t->U_1.V_5.Class;
  753.  
  754.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Terminal) | SET_ELEM(Tree_Referenced) | SET_ELEM(Tree_HasAttributes), W_19->Properties)) {
  755.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  756.         Tree_WN((LONGINT)W_19->Code);
  757.         IO_WriteS(Tree_f, (STRING)": ", 2L);
  758.         if (IN(Tree_String, W_19->Properties) && !IN(Tree_HasSelector, W_19->Properties)) {
  759.           IO_WriteS(Tree_f, (STRING)"(* ", 3L);
  760.           Tree_WE(W_19->Name);
  761.           IO_WriteS(Tree_f, (STRING)" *) yy", 6L);
  762.           Tree_WN((LONGINT)W_19->Code);
  763.           IO_WriteS(Tree_f, (STRING)": yy", 4L);
  764.           Tree_WN((LONGINT)W_19->Code);
  765.           IO_WriteS(Tree_f, (STRING)";", 1L);
  766.           IO_WriteNl(Tree_f);
  767.         } else {
  768.           Tree_WI(W_19->Selector);
  769.           IO_WriteS(Tree_f, (STRING)": yy", 4L);
  770.           Tree_WI(W_19->Selector);
  771.           IO_WriteS(Tree_f, (STRING)";", 1L);
  772.           IO_WriteNl(Tree_f);
  773.         }
  774.       }
  775.       return;
  776.     }
  777.   }
  778. }
  779.  
  780. static void ParsVariant
  781. # ifdef __STDC__
  782. (Tree_tTree t)
  783. # else
  784. (t)
  785. Tree_tTree t;
  786. # endif
  787. {
  788.   struct S_8 yyTempo;
  789.  
  790.   if (t == Tree_NoTree) {
  791.     return;
  792.   }
  793.   if (t->U_1.V_1.Kind == Tree_Class) {
  794.     {
  795.       register Tree_yClass *W_20 = &t->U_1.V_5.Class;
  796.  
  797.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Nonterminal) | SET_ELEM(Tree_Referenced) | SET_ELEM(Tree_HasAttributes), W_20->Properties)) {
  798.         if (IN(Tree_String, W_20->Properties) && !IN(Tree_HasSelector, W_20->Properties)) {
  799.           IO_WriteS(Tree_f, (STRING)"(* ", 3L);
  800.           Tree_WE(W_20->Name);
  801.           IO_WriteS(Tree_f, (STRING)" *) yy", 6L);
  802.           Tree_WN((LONGINT)W_20->Name);
  803.           IO_WriteS(Tree_f, (STRING)" = RECORD ", 10L);
  804.         } else {
  805.           IO_WriteS(Tree_f, (STRING)"yy", 2L);
  806.           Tree_WI(W_20->Selector);
  807.           IO_WriteS(Tree_f, (STRING)" = RECORD ", 10L);
  808.         }
  809.         TheClass = t;
  810.         Tree_ForallAttributes(W_20->Attributes, (Tree_ProcOfT)RecordField);
  811.         GenExt(W_20->Extensions);
  812.         IO_WriteS(Tree_f, (STRING)"END;", 4L);
  813.         IO_WriteNl(Tree_f);
  814.       }
  815.       ParsVariant(W_20->Next);
  816.       return;
  817.     }
  818.   }
  819. }
  820.  
  821. static void GenExt
  822. # ifdef __STDC__
  823. (Tree_tTree t)
  824. # else
  825. (t)
  826. Tree_tTree t;
  827. # endif
  828. {
  829.   struct S_9 yyTempo;
  830.  
  831.   if (t == Tree_NoTree) {
  832.     return;
  833.   }
  834.   if (t->U_1.V_1.Kind == Tree_Class) {
  835.     {
  836.       register Tree_yClass *W_21 = &t->U_1.V_5.Class;
  837.  
  838.       Tree_ForallAttributes(W_21->Attributes, (Tree_ProcOfT)RecordField);
  839.       GenExt(W_21->Extensions);
  840.       GenExt(W_21->Next);
  841.       return;
  842.     }
  843.   }
  844. }
  845.  
  846. static void Token
  847. # ifdef __STDC__
  848. (Tree_tTree t)
  849. # else
  850. (t)
  851. Tree_tTree t;
  852. # endif
  853. {
  854.   struct S_10 yyTempo;
  855.  
  856.   if (t == Tree_NoTree) {
  857.     return;
  858.   }
  859.   if (t->U_1.V_1.Kind == Tree_Class) {
  860.     {
  861.       register Tree_yClass *W_22 = &t->U_1.V_5.Class;
  862.  
  863.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Terminal) | SET_ELEM(Tree_Referenced), W_22->Properties)) {
  864.         WriteName(W_22->Name);
  865.         IO_WriteS(Tree_f, (STRING)" = ", 3L);
  866.         Tree_WN((LONGINT)W_22->Code);
  867.         IO_WriteNl(Tree_f);
  868.       }
  869.       return;
  870.     }
  871.   }
  872. }
  873.  
  874. static void RecordField
  875. # ifdef __STDC__
  876. (Tree_tTree t)
  877. # else
  878. (t)
  879. Tree_tTree t;
  880. # endif
  881. {
  882.   struct S_11 yyTempo;
  883.  
  884.   if (t == Tree_NoTree) {
  885.     return;
  886.   }
  887.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  888.     {
  889.       register Tree_yAttribute *W_23 = &t->U_1.V_10.Attribute;
  890.  
  891.       if ((Tree_NoCodeAttr & W_23->Properties) == 0X0L) {
  892.         if (IN(Tree_Nonterminal, TheClass->U_1.V_5.Class.Properties) || W_23->Name != Tree_iPosition) {
  893.           Tree_WI(W_23->Name);
  894.           IO_WriteS(Tree_f, (STRING)": ", 2L);
  895.           Tree_WI(W_23->Type);
  896.           IO_WriteS(Tree_f, (STRING)"; ", 2L);
  897.         }
  898.       }
  899.       return;
  900.     }
  901.   }
  902. }
  903.  
  904. static void PrecDefs
  905. # ifdef __STDC__
  906. (Tree_tTree t)
  907. # else
  908. (t)
  909. Tree_tTree t;
  910. # endif
  911. {
  912.   struct S_12 yyTempo;
  913.  
  914.   if (t == Tree_NoTree) {
  915.     return;
  916.   }
  917.   if (t->U_1.V_1.Kind == Tree_LeftAssoc) {
  918.     {
  919.       register Tree_yLeftAssoc *W_24 = &t->U_1.V_30.LeftAssoc;
  920.  
  921.       IO_WriteS(Tree_f, (STRING)"LEFT ", 5L);
  922.       PrecDefs(W_24->Names);
  923.       IO_WriteNl(Tree_f);
  924.       PrecDefs(W_24->Next);
  925.       return;
  926.     }
  927.   }
  928.   if (t->U_1.V_1.Kind == Tree_RightAssoc) {
  929.     {
  930.       register Tree_yRightAssoc *W_25 = &t->U_1.V_31.RightAssoc;
  931.  
  932.       IO_WriteS(Tree_f, (STRING)"RIGHT", 5L);
  933.       PrecDefs(W_25->Names);
  934.       IO_WriteNl(Tree_f);
  935.       PrecDefs(W_25->Next);
  936.       return;
  937.     }
  938.   }
  939.   if (t->U_1.V_1.Kind == Tree_NonAssoc) {
  940.     {
  941.       register Tree_yNonAssoc *W_26 = &t->U_1.V_32.NonAssoc;
  942.  
  943.       IO_WriteS(Tree_f, (STRING)"NONE ", 5L);
  944.       PrecDefs(W_26->Names);
  945.       IO_WriteNl(Tree_f);
  946.       PrecDefs(W_26->Next);
  947.       return;
  948.     }
  949.   }
  950.   if (t->U_1.V_1.Kind == Tree_Name) {
  951.     {
  952.       register Tree_yName *W_27 = &t->U_1.V_25.Name;
  953.  
  954.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  955.       Tree_WI(W_27->Name);
  956.       PrecDefs(W_27->Next);
  957.       return;
  958.     }
  959.   }
  960. }
  961.  
  962. static void Grammar
  963. # ifdef __STDC__
  964. (Tree_tTree t)
  965. # else
  966. (t)
  967. Tree_tTree t;
  968. # endif
  969. {
  970.   struct S_13 yyTempo;
  971.  
  972.   if (t == Tree_NoTree) {
  973.     return;
  974.   }
  975.   if (t->U_1.V_1.Kind == Tree_Class) {
  976.     {
  977.       register Tree_yClass *W_28 = &t->U_1.V_5.Class;
  978.  
  979.       if (W_28->Extensions->U_1.V_1.Kind == Tree_NoClass) {
  980.         {
  981.           register Tree_yClass *W_29 = &TheClass->U_1.V_5.Class;
  982.  
  983.           if (IN(Tree_String, W_29->Properties)) {
  984.             IO_WriteS(Tree_f, (STRING)"yy", 2L);
  985.             Tree_WN((LONGINT)W_29->Name);
  986.           } else {
  987.             WriteName(W_29->Name);
  988.           }
  989.         }
  990.         IO_WriteS(Tree_f, (STRING)" : ", 3L);
  991.         ActClass = t;
  992.         PrevActionIndex = 0;
  993.         IsImplicit = FALSE;
  994.         Tree_ForallAttributes(t, (Tree_ProcOfT)Rule);
  995.         if (W_28->Prec != Idents_NoIdent) {
  996.           IO_WriteS(Tree_f, (STRING)"PREC ", 5L);
  997.           Tree_WI(W_28->Prec);
  998.           IO_WriteS(Tree_f, (STRING)" ", 1L);
  999.         }
  1000.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1001.         IO_WriteNl(Tree_f);
  1002.         PrevActionIndex = 0;
  1003.         IsImplicit = TRUE;
  1004.         Tree_ForallAttributes(t, (Tree_ProcOfT)Implicit);
  1005.       } else {
  1006.         Rule(W_28->Extensions);
  1007.       }
  1008.       return;
  1009.     }
  1010.   }
  1011. }
  1012.  
  1013. static void Rule
  1014. # ifdef __STDC__
  1015. (Tree_tTree t)
  1016. # else
  1017. (t)
  1018. Tree_tTree t;
  1019. # endif
  1020. {
  1021.   struct S_14 yyTempo;
  1022.  
  1023.   if (t == Tree_NoTree) {
  1024.     return;
  1025.   }
  1026.   switch (t->U_1.V_1.Kind) {
  1027.   case Tree_Class:;
  1028.     {
  1029.       register Tree_yClass *W_30 = &t->U_1.V_5.Class;
  1030.  
  1031.       Grammar(t);
  1032.       Rule(W_30->Next);
  1033.       return;
  1034.     }
  1035.     break;
  1036.   case Tree_Child:;
  1037.     {
  1038.       register Tree_yChild *W_31 = &t->U_1.V_9.Child;
  1039.  
  1040.       if (SET_IS_SUBSET1(SET_ELEM(Tree_String) | SET_ELEM(Tree_Nonterminal), W_31->Class->U_1.V_5.Class.Properties)) {
  1041.         IO_WriteS(Tree_f, (STRING)"yy", 2L);
  1042.         Tree_WN((LONGINT)W_31->Type);
  1043.       } else {
  1044.         WriteName(W_31->Type);
  1045.       }
  1046.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  1047.       return;
  1048.     }
  1049.     break;
  1050.   case Tree_ActionPart:;
  1051.     {
  1052.       register Tree_yActionPart *W_32 = &t->U_1.V_11.ActionPart;
  1053.  
  1054.       if (IsLast(ActClass, t)) {
  1055.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1056.         if (PrevActionIndex != 0) {
  1057.           Node = GetBaseClass(TheClass);
  1058.           {
  1059.             register Tree_yClass *W_33 = &Node->U_1.V_5.Class;
  1060.  
  1061.             if (IN(Tree_HasAttributes, W_33->Properties)) {
  1062.               IO_WriteS(Tree_f, (STRING)" $$.", 4L);
  1063.               if (IN(Tree_String, W_33->Properties)) {
  1064.                 IO_WriteS(Tree_f, (STRING)"yy", 2L);
  1065.                 Tree_WN((LONGINT)W_33->Name);
  1066.               } else {
  1067.                 Tree_WI(W_33->Name);
  1068.               }
  1069.               IO_WriteS(Tree_f, (STRING)" := $", 5L);
  1070.               Tree_WN((LONGINT)PrevActionIndex);
  1071.               IO_WriteS(Tree_f, (STRING)".", 1L);
  1072.               if (IN(Tree_String, W_33->Properties)) {
  1073.                 IO_WriteS(Tree_f, (STRING)"yy", 2L);
  1074.                 Tree_WN((LONGINT)W_33->Name);
  1075.               } else {
  1076.                 Tree_WI(W_33->Name);
  1077.               }
  1078.               IO_WriteS(Tree_f, (STRING)";", 1L);
  1079.               IO_WriteNl(Tree_f);
  1080.             }
  1081.           }
  1082.         }
  1083.         Rule(W_32->Actions);
  1084.         IO_WriteS(Tree_f, (STRING)"} ", 2L);
  1085.       } else {
  1086.         IO_WriteS(Tree_f, (STRING)"xx", 2L);
  1087.         Tree_WN((LONGINT)W_32->Name);
  1088.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1089.       }
  1090.       PrevActionIndex = W_32->ParsIndex;
  1091.       return;
  1092.     }
  1093.     break;
  1094.   case Tree_Assign:;
  1095.     {
  1096.       register Tree_yAssign *W_34 = &t->U_1.V_36.Assign;
  1097.  
  1098.       Rule(W_34->Results);
  1099.       IO_WriteS(Tree_f, (STRING)":=", 2L);
  1100.       Rule(W_34->Arguments);
  1101.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1102.       IO_WriteNl(Tree_f);
  1103.       Rule(W_34->Next);
  1104.       return;
  1105.     }
  1106.     break;
  1107.   case Tree_Copy:;
  1108.     {
  1109.       register Tree_yCopy *W_35 = &t->U_1.V_37.Copy;
  1110.  
  1111.       Rule(W_35->Results);
  1112.       IO_WriteS(Tree_f, (STRING)" := ", 4L);
  1113.       Rule(W_35->Arguments);
  1114.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1115.       IO_WriteNl(Tree_f);
  1116.       Rule(W_35->Next);
  1117.       return;
  1118.     }
  1119.     break;
  1120.   case Tree_TargetCode:;
  1121.     {
  1122.       register Tree_yTargetCode *W_36 = &t->U_1.V_38.TargetCode;
  1123.  
  1124.       Rule(W_36->Code);
  1125.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1126.       IO_WriteNl(Tree_f);
  1127.       Rule(W_36->Next);
  1128.       return;
  1129.     }
  1130.     break;
  1131.   case Tree_Order:;
  1132.     {
  1133.       register Tree_yOrder *W_37 = &t->U_1.V_39.Order;
  1134.  
  1135.       Rule(W_37->Next);
  1136.       return;
  1137.     }
  1138.     break;
  1139.   case Tree_Check:;
  1140.     {
  1141.       register Tree_yCheck *W_38 = &t->U_1.V_40.Check;
  1142.  
  1143.       if (W_38->Statement != Tree_NoTree) {
  1144.         if (W_38->Condition != Tree_NoTree) {
  1145.           IO_WriteS(Tree_f, (STRING)"IF NOT (", 8L);
  1146.           Rule(W_38->Condition);
  1147.           IO_WriteS(Tree_f, (STRING)") THEN ", 7L);
  1148.           Rule(W_38->Statement);
  1149.           IO_WriteS(Tree_f, (STRING)"; END;", 6L);
  1150.           IO_WriteNl(Tree_f);
  1151.         } else {
  1152.           Rule(W_38->Statement);
  1153.           IO_WriteS(Tree_f, (STRING)";", 1L);
  1154.           IO_WriteNl(Tree_f);
  1155.         }
  1156.       } else {
  1157.         IO_WriteS(Tree_f, (STRING)"IF ", 3L);
  1158.         Rule(W_38->Condition);
  1159.         IO_WriteS(Tree_f, (STRING)" THEN END;", 10L);
  1160.         IO_WriteNl(Tree_f);
  1161.       }
  1162.       Rule(W_38->Next);
  1163.       return;
  1164.     }
  1165.     break;
  1166.   case Tree_Designator:;
  1167.     {
  1168.       register Tree_yDesignator *W_39 = &t->U_1.V_15.Designator;
  1169.  
  1170.       TheAttr = Tree_IdentifyAttribute(ActClass, W_39->Selector);
  1171.       if (TheAttr != Tree_NoTree) {
  1172.         Node = TheAttr->U_1.V_9.Child.Class;
  1173.         if (Node != Tree_NoTree) {
  1174.           IO_WriteS(Tree_f, (STRING)"$", 1L);
  1175.           if (!IsImplicit) {
  1176.             Tree_WN((LONGINT)TheAttr->U_1.V_9.Child.ParsIndex);
  1177.           } else {
  1178.             Tree_WN((LONGINT)(SHORTINT)(TheAttr->U_1.V_9.Child.ParsIndex + 1 - ActActionIndex));
  1179.           }
  1180.           if (IN(Tree_Nonterminal, Node->U_1.V_5.Class.Properties)) {
  1181.             Node = GetBaseClass(Node);
  1182.             if (IN(Tree_String, Node->U_1.V_5.Class.Properties) && !IN(Tree_HasSelector, Node->U_1.V_5.Class.Properties)) {
  1183.               IO_WriteS(Tree_f, (STRING)".yy", 3L);
  1184.               Tree_WN((LONGINT)Node->U_1.V_5.Class.Name);
  1185.             } else {
  1186.               IO_WriteS(Tree_f, (STRING)".", 1L);
  1187.               Tree_WI(Node->U_1.V_5.Class.Name);
  1188.             }
  1189.           } else {
  1190.             IO_WriteS(Tree_f, (STRING)".Scan", 5L);
  1191.             if (W_39->Attribute == Tree_iPosition) {
  1192.             } else if (IN(Tree_String, Node->U_1.V_5.Class.Properties) && !IN(Tree_HasSelector, Node->U_1.V_5.Class.Properties)) {
  1193.               IO_WriteS(Tree_f, (STRING)".yy", 3L);
  1194.               Tree_WN((LONGINT)Node->U_1.V_5.Class.Code);
  1195.             } else {
  1196.               IO_WriteS(Tree_f, (STRING)".", 1L);
  1197.               Tree_WI(Node->U_1.V_5.Class.Selector);
  1198.             }
  1199.           }
  1200.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1201.           Tree_WI(W_39->Attribute);
  1202.         } else {
  1203.           Tree_WI(W_39->Selector);
  1204.           IO_WriteS(Tree_f, (STRING)":", 1L);
  1205.           Tree_WI(W_39->Attribute);
  1206.         }
  1207.       } else {
  1208.         Tree_WI(W_39->Selector);
  1209.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1210.         Tree_WI(W_39->Attribute);
  1211.       }
  1212.       Rule(W_39->Next);
  1213.       return;
  1214.     }
  1215.     break;
  1216.   case Tree_Ident:;
  1217.     {
  1218.       register Tree_yIdent *W_40 = &t->U_1.V_16.Ident;
  1219.  
  1220.       TheAttr = Tree_IdentifyAttribute(ActClass, W_40->Attribute);
  1221.       Node = GetBaseClass(TheClass);
  1222.       if (TheAttr != Tree_NoTree) {
  1223.         if (IN(Tree_String, Node->U_1.V_5.Class.Properties) && !IN(Tree_HasSelector, Node->U_1.V_5.Class.Properties)) {
  1224.           IO_WriteS(Tree_f, (STRING)"$$.yy", 5L);
  1225.           Tree_WN((LONGINT)Node->U_1.V_5.Class.Name);
  1226.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1227.           Tree_WI(W_40->Attribute);
  1228.         } else {
  1229.           IO_WriteS(Tree_f, (STRING)"$$.", 3L);
  1230.           Tree_WI(Node->U_1.V_5.Class.Name);
  1231.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1232.           Tree_WI(W_40->Attribute);
  1233.         }
  1234.       } else {
  1235.         Tree_WI(W_40->Attribute);
  1236.       }
  1237.       Rule(W_40->Next);
  1238.       return;
  1239.     }
  1240.     break;
  1241.   case Tree_Any:;
  1242.     {
  1243.       register Tree_yAny *W_41 = &t->U_1.V_18.Any;
  1244.  
  1245.       StringMem_WriteString(Tree_f, W_41->Code);
  1246.       Rule(W_41->Next);
  1247.       return;
  1248.     }
  1249.     break;
  1250.   case Tree_Anys:;
  1251.     {
  1252.       register Tree_yAnys *W_42 = &t->U_1.V_19.Anys;
  1253.  
  1254.       Rule(W_42->Layouts);
  1255.       Rule(W_42->Next);
  1256.       return;
  1257.     }
  1258.     break;
  1259.   case Tree_LayoutAny:;
  1260.     {
  1261.       register Tree_yLayoutAny *W_43 = &t->U_1.V_22.LayoutAny;
  1262.  
  1263.       StringMem_WriteString(Tree_f, W_43->Code);
  1264.       Rule(W_43->Next);
  1265.       return;
  1266.     }
  1267.     break;
  1268.   default :
  1269.     break;
  1270.   }
  1271. }
  1272.  
  1273. static void Implicit
  1274. # ifdef __STDC__
  1275. (Tree_tTree t)
  1276. # else
  1277. (t)
  1278. Tree_tTree t;
  1279. # endif
  1280. {
  1281.   struct S_15 yyTempo;
  1282.  
  1283.   if (t == Tree_NoTree) {
  1284.     return;
  1285.   }
  1286.   if (t->U_1.V_1.Kind == Tree_ActionPart) {
  1287.     {
  1288.       register Tree_yActionPart *W_44 = &t->U_1.V_11.ActionPart;
  1289.  
  1290.       if (!IN(Tree_Generated, W_44->Properties) && !IsLast(ActClass, t)) {
  1291.         INCL(W_44->Properties, Tree_Generated);
  1292.         ActActionIndex = W_44->ParsIndex;
  1293.         IO_WriteS(Tree_f, (STRING)"xx", 2L);
  1294.         Tree_WN((LONGINT)W_44->Name);
  1295.         IO_WriteS(Tree_f, (STRING)" : {", 4L);
  1296.         if (PrevActionIndex != 0) {
  1297.           Node = GetBaseClass(TheClass);
  1298.           {
  1299.             register Tree_yClass *W_45 = &Node->U_1.V_5.Class;
  1300.  
  1301.             if (IN(Tree_HasAttributes, W_45->Properties)) {
  1302.               IO_WriteS(Tree_f, (STRING)" $$.", 4L);
  1303.               if (IN(Tree_String, W_45->Properties)) {
  1304.                 IO_WriteS(Tree_f, (STRING)"yy", 2L);
  1305.                 Tree_WN((LONGINT)W_45->Name);
  1306.               } else {
  1307.                 Tree_WI(W_45->Name);
  1308.               }
  1309.               IO_WriteS(Tree_f, (STRING)" := $", 5L);
  1310.               Tree_WN((LONGINT)(SHORTINT)(PrevActionIndex + 1 - ActActionIndex));
  1311.               IO_WriteS(Tree_f, (STRING)".", 1L);
  1312.               if (IN(Tree_String, W_45->Properties)) {
  1313.                 IO_WriteS(Tree_f, (STRING)"yy", 2L);
  1314.                 Tree_WN((LONGINT)W_45->Name);
  1315.               } else {
  1316.                 Tree_WI(W_45->Name);
  1317.               }
  1318.               IO_WriteS(Tree_f, (STRING)";", 1L);
  1319.               IO_WriteNl(Tree_f);
  1320.             }
  1321.           }
  1322.         }
  1323.         Rule(W_44->Actions);
  1324.         IO_WriteS(Tree_f, (STRING)"} .", 3L);
  1325.         IO_WriteNl(Tree_f);
  1326.       }
  1327.       PrevActionIndex = W_44->ParsIndex;
  1328.       return;
  1329.     }
  1330.   }
  1331. }
  1332.  
  1333. static void WriteName
  1334. # ifdef __STDC__
  1335. (Idents_tIdent Name)
  1336. # else
  1337. (Name)
  1338. Idents_tIdent Name;
  1339. # endif
  1340. {
  1341.   struct S_16 yyTempo;
  1342.  
  1343.   if (Name == iOper) {
  1344.     IO_WriteS(Tree_f, (STRING)"\\", 1L);
  1345.     Tree_WI(Name);
  1346.     return;
  1347.   }
  1348.   if (Name == iLeft) {
  1349.     IO_WriteS(Tree_f, (STRING)"\\", 1L);
  1350.     Tree_WI(Name);
  1351.     return;
  1352.   }
  1353.   if (Name == iRight) {
  1354.     IO_WriteS(Tree_f, (STRING)"\\", 1L);
  1355.     Tree_WI(Name);
  1356.     return;
  1357.   }
  1358.   if (Name == iNone) {
  1359.     IO_WriteS(Tree_f, (STRING)"\\", 1L);
  1360.     Tree_WI(Name);
  1361.     return;
  1362.   }
  1363.   if (Name == iPrec) {
  1364.     IO_WriteS(Tree_f, (STRING)"\\", 1L);
  1365.     Tree_WI(Name);
  1366.     return;
  1367.   }
  1368.   if (Name == iRule) {
  1369.     IO_WriteS(Tree_f, (STRING)"\\", 1L);
  1370.     Tree_WI(Name);
  1371.     return;
  1372.   }
  1373.   Tree_WI(Name);
  1374.   return;
  1375. }
  1376.  
  1377. void GramMod_BeginGramMod
  1378. # ifdef __STDC__
  1379. ()
  1380. # else
  1381. ()
  1382. # endif
  1383. {
  1384.   Strings_ArrayToString((STRING)"OPER", 4L, &s);
  1385.   iOper = Idents_MakeIdent(&s);
  1386.   Strings_ArrayToString((STRING)"RIGHT", 5L, &s);
  1387.   iRight = Idents_MakeIdent(&s);
  1388.   Strings_ArrayToString((STRING)"LEFT", 4L, &s);
  1389.   iLeft = Idents_MakeIdent(&s);
  1390.   Strings_ArrayToString((STRING)"NONE", 4L, &s);
  1391.   iNone = Idents_MakeIdent(&s);
  1392.   Strings_ArrayToString((STRING)"PREC", 4L, &s);
  1393.   iPrec = Idents_MakeIdent(&s);
  1394.   Strings_ArrayToString((STRING)"RULE", 4L, &s);
  1395.   iRule = Idents_MakeIdent(&s);
  1396. }
  1397.  
  1398. void GramMod_CloseGramMod
  1399. # ifdef __STDC__
  1400. ()
  1401. # else
  1402. ()
  1403. # endif
  1404. {
  1405. }
  1406.  
  1407. static void yyExit
  1408. # ifdef __STDC__
  1409. ()
  1410. # else
  1411. ()
  1412. # endif
  1413. {
  1414.   IO_CloseIO();
  1415.   Exit(1L);
  1416. }
  1417.  
  1418. void BEGIN_GramMod()
  1419. {
  1420.   static BOOLEAN has_been_called = FALSE;
  1421.  
  1422.   if (!has_been_called) {
  1423.     has_been_called = TRUE;
  1424.  
  1425.     BEGIN_IO();
  1426.     BEGIN_Tree();
  1427.     BEGIN_System();
  1428.     BEGIN_IO();
  1429.     BEGIN_Tree();
  1430.     BEGIN_IO();
  1431.     BEGIN_Strings();
  1432.     BEGIN_StringMem();
  1433.     BEGIN_Idents();
  1434.     BEGIN_Texts();
  1435.     BEGIN_Sets();
  1436.     BEGIN_TreeMod2();
  1437.     BEGIN_Tree();
  1438.     BEGIN_Strings();
  1439.  
  1440.     GramMod_yyf = IO_StdOutput;
  1441.     GramMod_Exit = yyExit;
  1442.     GramMod_BeginGramMod();
  1443.   }
  1444. }
  1445.